const dayjs = require('dayjs');
import { observable, action } from 'mobx-miniprogram';
// import dayjs from 'dayjs'; // 已在上方通过require引入，避免重复导入
import { standardizeGlobalStore } from '../helpers/store_standardizer.js';

// 缓存相关常量
const CACHE_PREFIX = 'MOBX_CACHE_';
const CACHE_INFO_KEY = 'CACHE_INFO';
const DEFAULT_EXPIRE_TIME = 30 * 60; // 默认30分钟

// 创建缓存管理Store
export const cacheStore = observable({
  // 缓存信息
  cacheInfo: {
    // 格式: 'key': { expireTime: timestamp }
  },
  
  // 缓存统计
  stats: {
    total: 0,
    expired: 0,
    valid: 0,
    size: 0 // 缓存大小(KB)
  },
  
  // 初始化
  init: action(function() {
    // 加载缓存信息
    try {
      const cacheInfo = wx.getStorageSync(CACHE_INFO_KEY);
      if (cacheInfo) {
        this.cacheInfo = cacheInfo;
      }
      
      // 自动清理过期缓存
      this.cleanExpiredCache();
      
      // 更新缓存统计
      this.updateStats();
    } catch (e) {
      console.error('初始化缓存管理失败:', e);
    }
  }),
  
  // 设置缓存
  set: action(function(key, data, expireSeconds = DEFAULT_EXPIRE_TIME) {
    try {
      const cacheKey = `${CACHE_PREFIX}${key}`;
      const expireTime = dayjs().valueOf() + expireSeconds * 1000;
      
      // 存储数据
      const cacheData = {
        data,
        expireTime,
        createTime: dayjs().valueOf()
      };
      
      wx.setStorageSync(cacheKey, cacheData);
      
      // 更新缓存信息
      this.cacheInfo[key] = {
        expireTime,
        size: JSON.stringify(cacheData).length / 1024 // 大致计算KB大小
      };
      
      // 保存缓存信息
      wx.setStorageSync(CACHE_INFO_KEY, this.cacheInfo);
      
      // 更新统计
      this.updateStats();
      
      return true;
    } catch (e) {
      console.error(`设置缓存[${key}]失败:`, e);
      return false;
    }
  }),
  
  // 获取缓存
  get: action(function(key) {
    try {
      const cacheKey = `${CACHE_PREFIX}${key}`;
      const cacheData = wx.getStorageSync(cacheKey);
      
      if (!cacheData) return null;
      
      // 检查是否过期
      if (cacheData.expireTime < dayjs().valueOf()) {
        // 缓存已过期，删除
        this.remove(key);
        return null;
      }
      
      return cacheData.data;
    } catch (e) {
      console.error(`获取缓存[${key}]失败:`, e);
      return null;
    }
  }),
  
  // 删除缓存
  remove: action(function(key) {
    try {
      const cacheKey = `${CACHE_PREFIX}${key}`;
      wx.removeStorageSync(cacheKey);
      
      // 更新缓存信息
      if (this.cacheInfo[key]) {
        delete this.cacheInfo[key];
        wx.setStorageSync(CACHE_INFO_KEY, this.cacheInfo);
      }
      
      // 更新统计
      this.updateStats();
      
      return true;
    } catch (e) {
      console.error(`删除缓存[${key}]失败:`, e);
      return false;
    }
  }),
  
  // 清空所有缓存
  clear: action(function() {
    try {
      // 清空所有缓存
      wx.clearStorageSync();
      
      // 重置缓存信息
      this.cacheInfo = {};
      
      // 重置统计信息
      this.stats = {
        total: 0,
        expired: 0,
        valid: 0,
        size: 0
      };
      
      return true;
    } catch (e) {
      console.error('清空缓存失败:', e);
      return false;
    }
  }),
  
  // 清理过期缓存
  cleanExpiredCache: action(function() {
    try {
      const now = dayjs().valueOf();
      const expiredKeys = [];
      
      // 查找过期键
      Object.keys(this.cacheInfo).forEach(key => {
        const info = this.cacheInfo[key];
        if (info.expireTime < now) {
          expiredKeys.push(key);
        }
      });
      
      // 删除过期缓存
      expiredKeys.forEach(key => {
        this.remove(key);
      });
      
      // 更新统计
      this.updateStats();
      
      return expiredKeys.length;
    } catch (e) {
      console.error('清理过期缓存失败:', e);
      return 0;
    }
  }),
  
  // 更新缓存统计信息
  updateStats: action(function() {
    try {
      const now = dayjs().valueOf();
      const keys = Object.keys(this.cacheInfo);
      
      // 基本统计
      this.stats.total = keys.length;
      this.stats.expired = keys.filter(key => this.cacheInfo[key].expireTime < now).length;
      this.stats.valid = this.stats.total - this.stats.expired;
      
      // 计算大小
      this.stats.size = keys.reduce((total, key) => {
        return total + (this.cacheInfo[key].size || 0);
      }, 0);
      
      // 四舍五入到2位小数
      this.stats.size = Math.round(this.stats.size * 100) / 100;
      
      return this.stats;
    } catch (e) {
      console.error('更新缓存统计失败:', e);
      return this.stats;
    }
  }),
  
  // 计算属性：获取缓存统计报告
  get statsReport() {
    return {
      ...this.stats,
      summary: `共${this.stats.total}个缓存，${this.stats.valid}个有效，${this.stats.expired}个过期，总大小约${this.stats.size}KB`
    };
  },
  
  // 刷新未保存的缓存
  flushPendingCache: action(function() {
    try {
      // 检查是否有挂起的缓存信息
      const pendingCaches = Object.keys(this.cacheInfo).filter(key => {
        // 检查缓存是否有'pending'标记
        const cache = wx.getStorageSync(`${CACHE_PREFIX}${key}`);
        return cache && cache.pendingUpdate === true;
      });
      
      if (pendingCaches.length === 0) {
        return true;
      }
      
      // 刷新挂起的缓存
      pendingCaches.forEach(key => {
        try {
          const cacheKey = `${CACHE_PREFIX}${key}`;
          const cache = wx.getStorageSync(cacheKey);
          
          if (cache) {
            // 清除挂起标记
            cache.pendingUpdate = false;
            wx.setStorageSync(cacheKey, cache);
          }
        } catch (e) {
          console.error(`刷新缓存[${key}]失败:`, e);
        }
      });
      
      // 更新缓存信息
      wx.setStorageSync(CACHE_INFO_KEY, this.cacheInfo);
      
      // 更新统计
      this.updateStats();
      
      return true;
    } catch (e) {
      console.error('刷新挂起缓存失败:', e);
      return false;
    }
  }),
  
  // 标记待更新缓存
  markCachePending: action(function(key) {
    try {
      const cacheKey = `${CACHE_PREFIX}${key}`;
      const cache = wx.getStorageSync(cacheKey);
      
      if (cache) {
        // 标记为待更新
        cache.pendingUpdate = true;
        wx.setStorageSync(cacheKey, cache);
        return true;
      }
      
      return false;
    } catch (e) {
      console.error(`标记缓存[${key}]为待更新失败:`, e);
      return false;
    }
  })
});

// 全局缓存帮助方法 - 支持链式操作
const cacheHelper = {
  // 设置缓存
  set(key, value, expireSeconds) {
    return cacheStore.set(key, value, expireSeconds);
  },
  
  // 获取缓存
  get(key) {
    return cacheStore.get(key);
  },
  
  // 删除缓存
  remove(key) {
    return cacheStore.remove(key);
  },
  
  // 清空所有缓存
  clear() {
    return cacheStore.clear();
  },
  
  // 清理过期缓存
  cleanExpired() {
    return cacheStore.cleanExpiredCache();
  },
  
  // 获取统计
  getStats() {
    return cacheStore.statsReport;
  },
  
  // 检查缓存是否存在
  has(key) {
    return cacheStore.get(key) !== null;
  }
};

// 应用标准化Store，确保拥有所有必要的方法和错误处理
export default standardizeGlobalStore(cacheStore, 'cache'); 